#[cfg(test)]
mod tests {

    // print! 将格式化文本输出到标准输出，不带换行符
    // println! 同上，但是在行的末尾添加换行符
    // format! 将格式化文本输出到 String 字符串
    // eprint!，eprintln! 输出到标准错误输出

    use std::fmt;

    // {} 适用于实现了 std::fmt::Display 特征的类型，用来以更优雅、更友好的方式格式化文本，例如展示给用户
    // {:?} 适用于实现了 std::fmt::Debug 特征的类型，用于调试场景
    #[test]
    fn range() {
        println!("Hello"); // => "Hello"
        println!("Hello, {}!", "world"); // => "Hello, world!"
        println!("The number is {}", 1); // => "The number is 1"
        println!("{:?}", (3, 4)); // => "(3, 4)"
        println!("{value}", value = 4); // => "4" // 具名
        println!("{} {}", 1, 2); // => "1 2"
        println!("{:04}", 42); // => "0042" with leading zeros

        let v = 3.1415926;
        // Display => 3.14
        println!("{:.2}", v); //格式化
        // Debug => 3.14
        println!("{:.2?}", v);
    }

    fn get_person() -> String {
        String::from("AAAAA")
    }

    #[test]
    fn simple() {
        //panic 不支持（2021版之前）
        //只能捕获普通的变量，对于更复杂的类型（例如表达式）可以先将它赋值给一个变量或使用以前的 name = expression 形式的格式化参数
        let person = get_person();
        println!("Hello, {person}!"); //直接输出
        panic!("Hello, {person}!"); //直接输出
    }

    #[test]
    fn format() {
        /*       字符串格式化默认使用空格进行填充，并且进行左对齐。
         */
        // 以下全部输出 "Hello x    !"
        // 为"x"后面填充空格，补齐宽度5
        println!("Hello {:5}!", "x");
        // 使用参数5来指定宽度
        println!("Hello {:1$}!", "y", 5);
        // 使用x作为占位符输出内容，同时使用5作为宽度
        println!("Hello {1:0$}!", 5, "z");
        // 使用有名称的参数作为宽度
        println!("Hello {:width$}!", "c", width = 5);
        //-----------------------------------
        // 使用参数5为参数x指定宽度，同时在结尾输出参数5 => Hello x    !5
        println!("Hello {:1$}!{}", "v", 5);
        /*
                数字填充:符号和 0
                数字格式化默认也是使用空格进行填充，但与字符串左对齐不同的是，数字是右对齐。
        */

        // 宽度是5 => Hello     5!
        println!("Hello {:5}!", 5);
        // 显式的输出正号 => Hello +5!
        println!("Hello {:+}!", 5);
        // 宽度5，使用0进行填充 => Hello 00005!
        println!("Hello {:05}!", 5);
        // 负号也要占用一位宽度 => Hello -0005!
        println!("Hello {:05}!", -5);

        println!("=========Aline=========");

        // 以下全部都会补齐5个字符的长度
        // 左对齐 => Hello x    !
        println!("Hello {:<5}!", "x");
        // 右对齐 => Hello     x!
        println!("Hello {:>5}!", "x");
        // 居中对齐 => Hello   x  !
        println!("Hello {:^5}!", "x");

        // 对齐并使用指定符号填充 => Hello x&&&&!
        // 指定符号填充的前提条件是必须有对齐字符
        println!("Hello {:&<5}!", "x");
    }

    #[test]
    fn double() {
        let v = 3.1415926;
        // 保留小数点后两位 => 3.14
        println!("{:.2}", v);
        // 带符号保留小数点后两位 => +3.14
        println!("{:+.2}", v);
        // 不带小数 => 3
        println!("{:.0}", v);
        // 通过参数来设定精度 => 3.1416，相当于{:.4}
        println!("{:.1$}", v, 4);

        let s = "hi我是Sunface孙飞";
        // 保留字符串前三个字符 => hi我
        println!("{:.3}", s);
        // {:.*}接收两个参数，第一个是精度，第二个是被格式化的值 => Hello abc!
        println!("Hello {:.*}!", 3, "abcdefg");
    }

    #[test]
    fn e() {
        //科学计数
        println!("{:2e}", 1000000000); // => 1e9
        println!("{:2E}", 1000000000); // => 1E9
    }

    #[test]
    fn pointer_addr() {
        let v = vec![1, 2, 3];
        println!("{:p}", v.as_ptr()) // => 0x600002324050
    }

    #[test]
    fn ten() {
        // #b, 二进制
        // #o, 八进制
        // #x, 小写十六进制
        // #X, 大写十六进制
        // x, 不带前缀的小写十六进制

        // 二进制 => 0b11011!
        println!("{:#b}!", 27);
        // 八进制 => 0o33!
        println!("{:#o}!", 27);
        // 十进制 => 27!
        println!("{}!", 27);
        // 小写十六进制 => 0x1b!
        println!("{:#x}!", 27);
        // 大写十六进制 => 0x1B!
        println!("{:#X}!", 27);

        // 不带前缀的十六进制 => 1b!
        println!("{:x}!", 27);

        // 使用0填充二进制，宽度为10 => 0b00011011!
        println!("{:#010b}!", 27);
    }

    #[test]
    fn trans() {
        // "{{" 转义为 '{'   "}}" 转义为 '}'   "\"" 转义为 '"'
        // => Hello "{World}"
        println!(" Hello \"{{World}}\" ");

        // 下面代码会报错，因为占位符{}只有一个右括号}，左括号被转义成字符串的内容
        // println!(" {{ Hello } ");
        // 也不可使用 '\' 来转义 "{}"
        // println!(" \{ Hello \} ")
    }

    #[derive(Debug)]
    struct Person {
        name: String,
        age: u8,
    }

    // 实现接口
    impl fmt::Display for Person {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "{}:>{} ", self.name, self.age)
        }
    }

    // 使用 {:?} 或 {:#?}
    // 为自定义类型实现 Display 特征
    // 使用 newtype 为外部类型实现 Display 特征
    #[test]
    fn range_dis() {
        let i = 3.1415926;
        let s = String::from("hello");
        let v = vec![1, 2, 3];
        let p = Person {
            name: "sunface".to_string(),
            age: 18,
        };
        println!("{}, {}, {:?}, {:?}", i, s, v, p);
        println!("{}", p);
    }

    struct Array(Vec<i32>);

    impl fmt::Display for Array {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "数组是：{:?}", self.0)
        }
    }

    #[test]
    fn new_type() {
        // Array 就是我们的 newtype，它将想要格式化输出的 Vec 包裹在内，最后只要为 Array 实现 Display 特征，即可进行格式化输出：
        let arr = Array(vec![1, 2, 3]);
        println!("{}", arr);
    }
}
